
/*
    Software License

    Copyright (C) 2021-05-24  Xoronos

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, version 3.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <https://www.gnu.org/licenses/>.
*/

/*
    Liabilities

    The software is provided "AS IS" without any warranty of any kind, either expressed,
    implied, or statutory, including, but not limited to, any warranty that the software
    will conform to specifications, any implied warranties of merchantability, fitness
    for a particular purpose, and freedom from infringement, and any warranty that the
    documentation will conform to the software, or any warranty that the software will
    be error free.

    In no event shall Xoronos be liable for any damages, including, but not limited to,
    direct, indirect, special or consequential damages, arising out of, resulting from,
    or in any way connected with this software, whether or not based upon warranty,
    contract, tort, or otherwise, whether or not injury was sustained by persons or
    property or otherwise, and whether or not loss was sustained from, or arose out of
    the results of, or use of, the software or services provided hereunder.

    To request the provided software under a different license you can contact us at
    support@xoronos.com
*/

#include "lexhelp_backend.h"

void lex_help_back_print_ac_option( int option, int command, char *buffer, char *all_args[]
 )
{
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[option], buffer );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[option] );
    XLEX_PRINT(  );
    lex_print_path_option( option, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s ", LEXTAB, LEXTAB );
    XLEX_PRINT(  );
    lex_print_path_option( option, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "can be generated using %s\n", all_args[command] );
    XLEX_PRINT(  );
}

void lex_help_print_encoding_conf( char *all_args[], int noline
 )
{
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%-48s%s %s",
              &( ( ( char * ) all_args[XEC_ENCODING_CONF] )[noline] ), LEXTAB,
              "the encoding configuration applied to the output files" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_decoding_conf( char *all_args[], int noline
 )
{
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%-48s%s %s",
              &( ( ( char * ) all_args[XDC_DECODING_CONF] )[noline] ), LEXTAB,
              "the encoding configuration applied to the input files" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_arithmetic_conf( char *all_args[], int noline
 )
{
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%-48s%s %s",
              &( ( ( char * ) all_args[XAC_ARITHMETIC_CONF] )[noline] ), LEXTAB,
              "the arithmetic configuration settings" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_sequence_conf( char *all_args[], int noline
 )
{
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%-48s%s %s",
              &( ( ( char * ) all_args[XSC_SEQUENCE_CONF] )[noline] ), LEXTAB,
              "the sequence layer configuration" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_permutation_conf( char *all_args[], int noline
 )
{
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%-48s%s %s",
              &( ( ( char * ) all_args[XPC_PERMUTATION_CONF] )[noline] ), LEXTAB,
              "the permutation layer configuration" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_loggining_conf( char *all_args[], int noline
 )
{
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%-48s%s %s",
              &( ( ( char * ) all_args[XLC_LOGGING_CONF] )[noline] ), LEXTAB,
              "the logging information from the Xoronos library" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_dump_encoding_param( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XDEP_DUMP_ENCODING_PARAM] )[noline] ), LEXTAB, comment,
              "is used to generate encoding parameters" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_decode_encode( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XDE_DECODE_ENCODE] )[noline] ), LEXTAB, comment,
              "is used to first decode and then encode a file" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_mine_xmatrix_comp_rnd( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XMXCR_MINE_XMATRIX_COMP_RND] )[noline] ), LEXTAB, comment,
              "mine a compressed Xoron matrix using a purely random algorithm" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_mine_xmatrix_comp_ot( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XMXCO_MINE_XMATRIX_COMP_OT] )[noline] ), LEXTAB, comment,
              "mine a compressed Xoron matrix using heuristics" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_permute_xmatrix_comp_random( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XPXCR_PERMUTE_XMATRIX_COMP_RANDOM] )[noline] ), LEXTAB, comment,
              "permute a Xoron matrix compressed randomly" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_permute_xmatrix_comp_deterministic( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XPXCD_PERMUTE_XMATRIX_COMP_DETERMINISTIC] )[noline] ), LEXTAB, comment,
              "permute a Xoron matrix compressed deterministicly" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_permute_xmatrix_comp_confidential( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XPXCS_PERMUTE_XMATRIX_COMP_CONFIDENTIAL] )[noline] ), LEXTAB, comment,
              "permute a Xoron matrix compressed with a monomial key" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_decompress_xmatrix( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XDX_DECOMPRESS_XMATRIX] )[noline] ), LEXTAB, comment,
              "decompress a xoron matrix comrpessed" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_check_xmatrix_comp( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XCXC_CHECK_XMATRIX_COMP] )[noline] ), LEXTAB, comment,
              "perform sanity checks to a Xoron matrix compressed" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_check_xmatrix( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XCX_CHECK_XMATRIX] )[noline] ), LEXTAB, comment,
              "perform sanity checks to a Xoron matrix" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_make_point( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XMP_MAKE_POINT] )[noline] ), LEXTAB, comment,
              "generate a point, used as seed for pseudo random algorithms" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_make_confidential_pseudo_random_number( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XMSPRN_MAKE_CONFIDENTIAL_PSEUDO_RANDOM_NUMBER] )[noline] ), LEXTAB,
              comment, "generate a pseudo random number with a key" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_make_start_point( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XMSP_MAKE_START_POINT] )[noline] ), LEXTAB, comment,
              "generate a start point, which is required for a binomial key generation" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_make_monomial_key( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XMMK_MAKE_MONOMIAL_KEY] )[noline] ), LEXTAB, comment,
              "generate a monomial key, usually referred to as private key for classical computers" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_make_binomial_key( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XMBK_MAKE_BINOMIAL_KEY] )[noline] ), LEXTAB, comment,
              "generate a binomial key, usually referred to as public key for classical computers" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_exchange_monomial_key( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XEMK_EXCHANGE_MONOMIAL_KEY] )[noline] ), LEXTAB, comment,
              "exchange a monomial key for classical computers" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_make_monovalent_key( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XMMK_MAKE_MONOVALENT_KEY] )[noline] ), LEXTAB, comment,
              "generate a monovalent key (public), polyvalent key and polyvalent proof (both private)" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_exchange_polyvalent_key( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XEPK_EXCHANGE_POLYVALENT_KEY] )[noline] ), LEXTAB, comment,
              "perform the quantum polyvalent key exchange" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_check_monovalent_key( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XCMK_CHECK_MONOVALENT_KEY] )[noline] ), LEXTAB, comment,
              "verify the validity of a monovalent key" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_make_commitment_binomial_key( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XMCBK_MAKE_COMMITMENT_BINOMIAL_KEY] )[noline] ), LEXTAB, comment,
              "generate a monomial/binomial commitment pair" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_make_commitment_sym_signature( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XMCSS_MAKE_COMMITMENT_SYM_SIGNATURE] )[noline] ), LEXTAB, comment,
              "generate a monomial/binomial commitment pair, from a symmetric signature" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_make_commitment_sym_certificate( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XMCSC_MAKE_COMMITMENT_SYM_CERTIFICATE] )[noline] ), LEXTAB, comment,
              "generate a monomial/binomial commitment pair, from a symmetric certificate" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_make_response( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XMR_MAKE_RESPONSE] )[noline] ), LEXTAB, comment,
              "generate a response to a binomial commitment" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_make_monomial_proof( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XMMP_MAKE_MONOMIAL_PROOF] )[noline] ), LEXTAB, comment,
              "generate a proof given a monomial response" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_make_monomial_proof_sym_signature( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XMMPSS_MAKE_MONOMIAL_PROOF_SYM_SIGNATURE] )[noline] ), LEXTAB, comment,
              "generate a proof given a monomial response and a signature" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_make_monomial_proof_sym_certificate( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XMMPSC_MAKE_MONOMIAL_PROOF_SYM_CERTIFICATE] )[noline] ), LEXTAB,
              comment, "generate a proof given a monomial response and a certificate" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_check_monomial_proof( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XCMP_CHECK_MONOMIAL_PROOF] )[noline] ), LEXTAB, comment,
              "verify a monomial proof" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_check_monomial_proof_sym_signature( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XCMPSS_CHECK_MONOMIAL_PROOF_SYM_SIGNATURE] )[noline] ), LEXTAB,
              comment, "verify a monomial proof given a signature" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_check_monomial_proof_sym_certificate( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XCMPSC_CHECK_MONOMIAL_PROOF_SYM_CERTIFICATE] )[noline] ), LEXTAB,
              comment, "verify a monomial proof given a certificate" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_make_signature_symmetric( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XMSS_MAKE_SIGNATURE_SYMMETRIC] )[noline] ), LEXTAB, comment,
              "generate a symmetric signature" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_make_signature_asymmetric( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XMSA_MAKE_SIGNATURE_ASYMMETRIC] )[noline] ), LEXTAB, comment,
              "generate an asymmetric signature" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_make_ring_signature( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XMRS_MAKE_RING_SIGNATURE] )[noline] ), LEXTAB, comment,
              "generate a ring signature" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_permute_ring_signature( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XPRS_PERMUTE_RING_SIGNATURE] )[noline] ), LEXTAB, comment,
              "permute a ring signature" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_make_certificate_symmetric( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XMCS_MAKE_CERTIFICATE_SYMMETRIC] )[noline] ), LEXTAB, comment,
              "generate a symmetric certificate to transfer a monovalent key" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_make_certificate_asymmetric( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XMCA_MAKE_CERTIFICATE_ASYMMETRIC] )[noline] ), LEXTAB, comment,
              "generate an asymmetric certificate to transfer binomial key" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_check_signature_symmetric( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XCSS_CHECK_SIGNATURE_SYMMETRIC] )[noline] ), LEXTAB, comment,
              "verify a symmetric signature" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_check_signature_asymmetric( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XCSA_CHECK_SIGNATURE_ASYMMETRIC] )[noline] ), LEXTAB, comment,
              "verify an asymmetric signature" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_check_ring_signature( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XCRS_CHECK_RING_SIGNATURE] )[noline] ), LEXTAB, comment,
              "verify a ring signature" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_check_certificate_symmetric( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XCCS_CHECK_CERTIFICATE_SYMMETRIC] )[noline] ), LEXTAB, comment,
              "veriy a symmetric certificate" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_check_certificate_asymmetric( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XCCA_CHECK_CERTIFICATE_ASYMMETRIC] )[noline] ), LEXTAB, comment,
              "veriy an asymmetric certificate" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_make_hash( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XMH_MAKE_HASH] )[noline] ), LEXTAB, comment, "generate an hash file" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_make_checksum( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XMC_MAKE_CHECKSUM] )[noline] ), LEXTAB, comment,
              "generate checksums file to speed up the hashing algorithm" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_check_checksum( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XCC_CHECK_CHECKSUM] )[noline] ), LEXTAB, comment,
              "verify generated checksums file" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_check_hash( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XCH_CHECK_HASH] )[noline] ), LEXTAB, comment,
              "verify generated hash file" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_convert_symmetric_certificate_to_monovalent_key( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XCSCTMK_CONVERT_SYMMETRIC_CERTIFICATE_TO_MONOVALENT_KEY] )[noline] ),
              LEXTAB, comment, "convert a symmetric certificate file to a monovalent key file" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_convert_asymmetric_certificate_to_binomial_key( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XCACTBK_CONVERT_ASYMMETRIC_CERTIFICATE_TO_BINOMIAL_KEY] )[noline] ),
              LEXTAB, comment, "convert an asymmetric certificate file to a binomial key file" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_convert_asymmetric_signature_to_binomial_key( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XCASTBK_CONVERT_ASYMMETRIC_SIGNATURE_TO_BINOMIAL_KEY] )[noline] ),
              LEXTAB, comment, "convert an asymmetric signature file to a binomial key file" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_convert_symmetric_signature_to_binomial_key( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XCSSTBK_CONVERT_SYMMETRIC_SIGNATURE_TO_BINOMIAL_KEY] )[noline] ),
              LEXTAB, comment, "convert a symmetric signature file to a binomial key file" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_convert_binomial_key_to_asymmetric_signature( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XCBKTAS_CONVERT_BINOMIAL_KEY_TO_ASYMMETRIC_SIGNATURE] )[noline] ),
              LEXTAB, comment, "convert a binomial key file to a symmetric signature file" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_convert_binomial_key_to_symmetric_signature( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XCBKTSS_CONVERT_BINOMIAL_KEY_TO_SYMMETRIC_SIGNATURE] )[noline] ),
              LEXTAB, comment, "convert a binomial key file to a symmetric signature file" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_convert_hash_to_monomial_key( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XCHTMK_CONVERT_HASH_TO_MONOMIAL_KEY] )[noline] ), LEXTAB, comment,
              "convert a hash file to a monomial key file" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_convert_hash_to_point( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XCHTP_CONVERT_HASH_TO_POINT] )[noline] ), LEXTAB, comment,
              "convert a hash file to a point file" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_convert_point_to_monomial_key( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XCPTMK_CONVERT_POINT_TO_MONOMIAL_KEY] )[noline] ), LEXTAB, comment,
              "convert a point file to a monomial key file" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_convert_monomial_key_to_point( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XCMKTP_CONVERT_MONOMIAL_KEY_TO_POINT] )[noline] ), LEXTAB, comment,
              "convert a monomial key file to a point file" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_convert_binomial_key_to_start_point( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XCBKTSP_CONVERT_BINOMIAL_KEY_TO_START_POINT] )[noline] ), LEXTAB,
              comment, "convert a binomial key file to a start point file" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_convert_start_point_to_point( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XCSPTP_CONVERT_START_POINT_TO_POINT] )[noline] ), LEXTAB, comment,
              "convert a start point file to a point file" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_convert_point_to_start_point( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XCPTSP_CONVERT_POINT_TO_START_POINT] )[noline] ), LEXTAB, comment,
              "convert a point file to a start point file" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_convert_monomial_key_to_monomial_commitment( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XCMKTMC_CONVERT_MONOMIAL_KEY_TO_MONOMIAL_COMMITMENT] )[noline] ),
              LEXTAB, comment, "convert a monomial key file to a monomial commitment file" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_convert_monomial_commitment_to_monomial_key( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XCMCTMK_CONVERT_MONOMIAL_COMMITMENT_TO_MONOMIAL_KEY] )[noline] ),
              LEXTAB, comment, "convert a monomial commitment file to a monomial key file" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_split_symmetric( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XSS_SPLIT_SYMMETRIC] )[noline] ), LEXTAB, comment,
              "generate a challenge and solution files to speed up encryption" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_encrypt_asymmetric( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XEA_ENCRYPT_ASYMMETRIC] )[noline] ), LEXTAB, comment,
              "perform an asymmetric encryption with a binomial key" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_encrypt_symmetric( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XES_ENCRYPT_SYMMETRIC] )[noline] ), LEXTAB, comment,
              "perform a symmetric encryption with a monomial key" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_join_symmetric( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XJS_JOIN_SYMMETRIC] )[noline] ), LEXTAB, comment,
              "join a generated challenge and solution file" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_decipher_asymmetric( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XDA_DECIPHER_ASYMMETRIC] )[noline] ), LEXTAB, comment,
              "decipher a file with a monomial key" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_decipher_symmetric( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XDS_DECIPHER_SYMMETRIC] )[noline] ), LEXTAB, comment,
              "decipher a file with a monomial key" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_check_complete_blocks( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XCCB_CHECK_COMPLETE_BLOCK] )[noline] ), LEXTAB, comment,
              "check if the block file contains the entire file" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_make_block( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XMB_MAKE_BLOCK] )[noline] ), LEXTAB, comment,
              "divide a file given an offset and length " );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_merge_block( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XCB_COMBINE_BLOCKS] )[noline] ), LEXTAB, comment,
              "merge two block files" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_strip_header_from_block( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XSHFB_STRIP_HEADER_FROM_BLOCK] )[noline] ), LEXTAB, comment,
              "remove header from a block file" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_print_header( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XPH_PRINT_HEADER] )[noline] ), LEXTAB, comment,
              "print file header information" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_print_lib_info( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XPLI_PRINT_LIB_INFO] )[noline] ), LEXTAB, comment,
              "print Xoronos library information" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_get_capacity( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XGC_GET_CAPACITY] )[noline] ), LEXTAB, comment,
              "get the capacity of the envelop file" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_make_steganography_raw( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XMSR_MAKE_STEGANOGRAPHY_RAW] )[noline] ), LEXTAB, comment,
              "embed a raw file in the envelop file" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_make_steganography_block( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XMSB_MAKE_STEGANOGRAPHY_BLOCK] )[noline] ), LEXTAB, comment,
              "create a block and embed it in the envelop file" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_extract_steganography_raw( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XESR_EXTRACT_STEGANOGRAPHY_RAW] )[noline] ), LEXTAB, comment,
              "extract a raw file from the envelop file" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_extract_steganography_block( char prelude[256], char *all_args[], int noline
 )
{
    char comment[3];

    if ( strncmp( prelude, "", 256 ) != 0 ) {
        comment[0] = '#';
        comment[1] = ' ';
        comment[2] = '\0';
    } else {
        comment[0] = '\0';
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n%s%-48s%s %s%s", prelude,
              &( ( ( char * ) all_args[XESB_EXTRACT_STEGANOGRAPHY_BLOCK] )[noline] ), LEXTAB, comment,
              "extract a block embedded in the envelop file" );
    XLEX_PRINT(  );
    if ( noline == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_help_print_arch( char *all_args[]
 )
{

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XPC_ARCH],
              "the architecture in bits\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s 256\n", LEXTAB, LEXTAB, "usage: ",
              all_args[XPC_ARCH] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "%s%-48s default 256, allowed values are either 128 or 256 \n", LEXTAB, LEXTAB );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s", LEXTAB, all_args[XPC_SHARED_LIB],
              "the path of the shared library\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s%s ", LEXTAB, LEXTAB, "usage: ",
              all_args[XPC_SHARED_LIB] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "/usr/lib/xoronos/xrnlib-256.so \n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s rule: the %s should not be specified if the\n",
              LEXTAB, LEXTAB, all_args[XPC_ARCH] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s%-48s %s option is specified", LEXTAB, LEXTAB,
              all_args[XPC_SHARED_LIB] );
    XLEX_PRINT(  );

}

